
const fs = require('fs');
const path = require('path');

// 🚀 内存中的规则缓存 - 实现毫秒级响应的关键
let memoryRules = null;
let lastUpdateTime = 0;

// 🚀 内存预热 - 启动时预分配内存空间
const PREALLOC_SIZE = 1024; // 预分配1KB内存
let preAllocatedBuffer = Buffer.alloc(PREALLOC_SIZE);

// 🚀 高性能字符串拼接缓存
let stringCache = new Map();

/**
 * 规则服务器，按照 whistle 官方文档规范实现
 * 这个函数会被 whistle 调用，用于获取插件提供的规则
 * 
 * @param {Object} server - whistle 提供的 server 对象
 * @param {Object} options - whistle 提供的配置对象
 */
module.exports = (server, options) => {
  console.log('[NoHost] 初始化 Rules Server (0延迟内存模式)');
  
  try {
    // 注册请求处理函数
    server.on('request', async (req, res) => {
      try {
        // 🚀 毫秒级规则获取 - 极速响应
        const rules = await generateActiveRules();
        
        // 设置内容类型
        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
        
        // 返回规则文本 - whistle 会解析这些规则并应用
        res.end(rules);
        
      } catch (error) {
        console.error('[NoHost] RulesServer 错误:', error);
        res.statusCode = 500;
        res.end('# NoHost Rules Server Error\n');
      }
    });
  } catch (error) {
    console.error('[NoHost] RulesServer 初始化失败:', error);
  }
};

// 🚀 设置内存规则 - 毫秒级极速更新
function setMemoryRules(rules) {
  // 🚀 高性能字符串处理
  if (Array.isArray(rules)) {
    const cacheKey = rules.length.toString();
    let cachedJoiner = stringCache.get(cacheKey);
    if (!cachedJoiner) {
      cachedJoiner = '\n';
      stringCache.set(cacheKey, cachedJoiner);
    }
    memoryRules = rules.join(cachedJoiner);
  } else {
    memoryRules = rules;
  }
  
  lastUpdateTime = Date.now();
  
  // 🚀 定期清理缓存，防止内存泄漏
  cleanCache();
  
  // 🚀 性能优化：生产环境下完全无日志开销
  if (process.env.NODE_ENV !== 'production') {
    console.log('[NoHost] ⚡ 内存规则毫秒级更新完成');
  }
}

// 🚀 清空内存规则 - 毫秒级极速清理
function clearMemoryRules() {
  memoryRules = '# NoHost Plugin Rules\n# All environments deactivated\n';
  lastUpdateTime = Date.now();
  if (process.env.NODE_ENV !== 'production') {
    console.log('[NoHost] ⚡ 内存规则毫秒级清空完成');
  }
}

// 🚀 清理缓存 - 防止内存泄漏
function cleanCache() {
  if (stringCache.size > 100) { // 限制缓存大小
    stringCache.clear();
    if (process.env.NODE_ENV !== 'production') {
      console.log('[NoHost] 🧹 字符串缓存已清理');
    }
  }
}

// 导出内存操作函数
module.exports.setMemoryRules = setMemoryRules;
module.exports.clearMemoryRules = clearMemoryRules;
module.exports.cleanCache = cleanCache;

/**
 * 生成当前激活环境的所有规则
 * 🚀 内存优先版：优先使用内存规则，回退到文件读取
 */
async function generateActiveRules() {
  try {
    // 🚀 毫秒级内存读取 - 极速优先
    if (memoryRules !== null) {
      return memoryRules; // 直接返回，无日志开销
    }
    
    // 回退：读取rules.txt文件
    const rulesFilePath = path.join(__dirname, '../rules.txt');
    
    if (fs.existsSync(rulesFilePath)) {
      const rulesContent = fs.readFileSync(rulesFilePath, 'utf8');
      return rulesContent;
    } else {
      // 如果文件不存在，返回默认规则
      return '# NoHost Plugin Rules\n# No active environments\n';
    }
  } catch (error) {
    console.error('[NoHost] 读取规则失败:', error);
    return '# NoHost Plugin Rules\n# Error: ' + error.message;
  }
}

/**
 * 解析host配置为whistle规则格式 (保留实用工具函数)
 * 输入: "127.0.0.1:8181 dgvip360.drivergenius3.com"
 * 输出: "dgvip360.drivergenius3.com 127.0.0.1:8181"
 */
function parseHostConfig(hostConfig) {
  if (!hostConfig || typeof hostConfig !== 'string') {
    return '';
  }

  const parts = hostConfig.trim().split(/\s+/);
  if (parts.length >= 2) {
    const proxy = parts[0]; // 127.0.0.1:8181
    const domain = parts[1]; // dgvip360.drivergenius3.com
    return `${domain} ${proxy}`;
  }

  return '';
}


